Method of utilizing variable data fields with a page description language

ABSTRACT

A computer implemented method for generating a plurality of bit maps suitable for high-speed printing includes the steps of: (a) providing a page description code specification, where the page description code specification defines at least one data area, and the page description code further defines a graphics state corresponding to the data area, where the graphics state including at least one attribute which controls the appearance of data in the data area; (b) interpreting the page description code specification, and during the interpretation step, identifying the data area defined by the page description code specification; (c) upon the identification of the variable data area in step (b), applying the graphics state corresponding to the data area to a set of alphanumeric characters so as to generate a plurality of character bit maps; (d) storing the plurality of character bit maps; (e) retrieving a variable data item from a plurality of variable data items; (f) associating the variable data item with the plurality of character bit maps; (g) generating a variable data bit map for the variable data using the character bit maps; and (h) repeating steps (e) through (g) for remaining variable data items in the plurality of variable data items. Thus, the stored character bit maps are used repeatedly to generate a plurality of variable data bit maps.

CROSS-REFERENCE TO RELATED APPLICATIONS

[0001] This application is a continuation of U.S. application Ser. No.09/299,502, filed Apr. 26, 1999; which was a continuation of U.S.application Ser. No. 08/896,899, filed Jul. 18, 1997, and issued as U.S.Pat. No. 5,937,153; which is a continuation-in-part of U.S. applicationSer. No. 08/373,582, filed Jan. 18, 1995, and issued as U.S. Pat. No.5,729,665.

BACKGROUND OF THE INVENTION

[0002] The present invention relates to the high-speed printingindustry, and more particularly, to a method for printing variable datausing a page description language in a high-speed printing environment.

[0003] Application programs, such as Adobe Illustrator®, typicallyinclude a program which generates a specification of a screen or page'scontents in a page description language. The specification, or pagedescription code, provides instructions as to how to generate the imagein a printer. The page description code is transferred from theapplication program to a printer, where it is executed to generate a bitmap of the page. The most commonly used page description language isPostScript®, which is a machine independent language produced by AdobeSystems, Inc.

[0004] An application program page typically contains a number of dataareas with either graphic or alphanumeric data. The PostScript languageincludes commands that define or build “graphics states” for each of thedata areas on the page. These graphics states are sets of defaultattributes such as angle, scale factor, type-font, location, etc., whichdefine how data is to appear on the page. Often, multiple graphicsstates are defined for a single page, with the different graphic statescorresponding to different data areas on the page. Examples of commandsthat are used in PostScript to build a graphics state are: 20rotate,/Times-Roman findfont, 14 scalefont, and setfont. In addition tocommands which build graphics states, PostScript specifications alsoinclude the graphic or alphanumeric data which is displayed in the dataareas, as well as a print command such as “SHOW”, which causes a bit mapto be generated for the data.

[0005] In the past, page description languages, including PostScript,have only been used to print static data pages, because page descriptionlanguages lack the functionality required for variable data printing. Invariable data printing, each page shares a common background, and thedisplayed data in at least one data field changes for each page. Upuntil now, it has not been possible to print pages of variable data withpage description languages such as PostScript, because the pagedescription languages are unable to save page backgrounds and graphicsstates from a page specification, and are thus unable reuse the samebackground and graphics states when printing subsequent pages. Thus,with page description languages such as PostScript, whether the entirepage is changed, or only a single item of data on the page is changed, anew page description language specification is generated to print eachseparate page.

[0006] For example, if thousands of copies of a mass mailingadvertisement were to be printed, each copy being identical except forthe recipient's name and address, it would be necessary to generate anew PostScript specification defining the page background, and thegraphics states for the name and address fields, for each new name andaddress that is printed. Hence, to print 50 advertisements, it would benecessary to generate 50 PostScript specifications which each definevirtually the same image.

[0007] In general, PostScript specifications are very complex andrequire extensive processing to generate and execute. Thus, generating anew PostScript specification each time a page of variable data isprinted consumes an immense amount of processing time. In high-speedprinting systems, it is typically the processing time, not the printerhardware, which determines the speed at which pages can be printed.Therefore, the processing required to repetitively redefine the samebackground and graphics states for each page of variable datasignificantly slows the entire printing system.

[0008] Due to the amount of processing time consumed in redefining thepage template and graphics states for each new page of data that isprinted, as well as the resultant effect on printing speed, it isdesirable to have a method for processing variable data wherein oncedefined, the template and graphics states for a page can be stored andreused for printing subsequent pages. Further, it is desirable to have amethod for printing variable data which is compatible with existingprinting systems and page description languages, such as PostScript, andwhich is capable of processing variable data in a high-speed industrialprinting system.

SUMMARY OF THE INVENTION

[0009] It is an object of the present invention to provide a method forutilizing variable data with a page description language, which enablesthe template and graphics states for a page of variable data to bedefined and stored; and which enables the stored graphics states to beassociated with multiple items of variable data from a database or mergefile; so that once stored, the graphics states can be repeatedly appliedto the items of variable data to print multiple pages of variable dataor multiple variable data bitmaps. Further, it is an object of thepresent invention to provide such a method which is compatible withexisting page description languages, and which can be used in ahigh-speed industrial printing system.

[0010] The method of the present invention is implemented by means of acontrol task which executes in conjunction with a page description codeinterpretive program, such as a PostScript program, to identify variabledata areas in the page description code specification, and reserve thegraphics states for the variable data areas as they are defined by thespecification. After the interpreter program has executed, a merge taskis initiated. The merge task associates items of variable data from adata file with the reserved graphics states, generates a bit map foreach variable data area, merges the bit maps with the page template, andoutputs a complete bit map for the page. Accordingly, in the method ofthe present invention, bit maps for multiple pages of variable data aregenerated from a single page description language specification.

[0011] The present invention assumes the generation of a pagespecification in PostScript, or another similar page descriptionlanguage, by the application program, and the transfer of thisspecification to a printer. According to the present invention, acontrol task activates and monitors the PostScript interpreter programin the printer. As the interpreter executes, it defines graphics statesfor the data areas on the page. The PostScript attributes for a graphicsstate are stored in a stack as they are defined, so that at any givenpoint in the code, the stack represents all of the PostScript attributesfor the current graphics state.

[0012] When the control task identifies a print command in the code, thecontrol task interrupts the interpreter to determine whether the data tobe printed is variable data. If the data is variable, the currentgraphics state, consisting of the attributes then existing in the stackand job specific attributes which are defined in a job file, is linkedto the data area and reserved in an internal database. Further,character bit maps are generated in accordance with the graphics state,and linked to and reserved with the graphics state. After the graphicsstate and character bit maps have been reserved, the PostScriptinterpreter is resumed at the line of code following the print command.

[0013] The interpreter continues executing until either the control taskdetects another print command, or the last line of code is reached. If asecond print command is detected, the interpreter is interrupted againand the above steps repeated, to reserve the stack contents and jobattributes for the second data area, and to generate and store a secondset of character bit maps. The control task continues in this mannermonitoring and interrupting the interpreter program, until all of thevariable data areas on the page have been detected, and graphics statesand possibly character bit maps for the variable data areas have beenreserved in the database.

[0014] As the PostScript interpreter executes, a bit map of thenon-variable background graphics and text, otherwise referred to as a“template”, is generated for the page. At the last code command, whichin PostScript is typically “SHOWPAGE,” the control task terminates thePostScript interpreter, and reserves the template in the database.

[0015] The merge task is then initiated to print variable data pagesusing the reserved page template, graphics states and character bitmaps. The merge task begins by retrieving a merge file containing thevariable data to be printed. After retrieving the merge file, the taskidentifies the correct template for the current page, and the names ofthe graphics states related to that template, from data in the mergefile. Then, using the name of the first graphics state reserved for thetemplate, the merge task retrieves the graphics state from the databaseand the character bit maps linked to that state. The merge task thenretrieves data corresponding to that graphics state from the appropriatefield in the merge file, and generates a bit map of the data inaccordance with the graphics state and character bit maps. The mergetask then merges the data bit map into the template. After the bit maphas been generated and merged, the merge task identifies retrievesanother graphics state for the template and repeats the process. Ifthere are no more graphics states which correspond to variable dataareas on the page, the merge task outputs the finished bit map for thepage.

[0016] After the first page of data has been printed, the merge taskretrieves a “clean” template from the database, and again identifies thegraphics states for the page. The merge task then retrieves the nextrecord of variable data from the database, and generates variable databit maps for each of the fields in the record, in accordance with thereserved graphics states and character bit maps which correspond to eachof the fields. The merge task continues in this manner, identifyingvariable data areas and generating bit maps for the variable data in themerge file, until a page has been printed for each variable data recordin the file.

[0017] The method of the present invention is advantageous in that oncethe graphics states and template have been defined for a variable datapage, they can be reused to print multiple pages of variable data withonly a minimal amount of additional processing.

[0018] Accordingly, it is an object of the present invention to providea method for printing variable data with a page description language; amethod which increases the speed at which variable data pages can beprinted; a method which enables the printing attributes for a page to besaved and used for printing multiple pages of data; and a method whichis compatible with existing page description languages and printingsystems.

[0019] Other objects and advantages of the present invention will beapparent from the following description, the accompanying drawings andthe appended claims.

BRIEF DESCRIPTION OF THE DRAWINGS

[0020]FIG. 1 is a data flow diagram illustrating the preferredembodiment of the method of the present invention;

[0021]FIG. 2 is an example of a variable data page generated inaccordance with the method of the present invention.

DETAILED DESCRIPTION

[0022] The present invention provides a computer-implemented method forreserving graphics states, which enables a page description language tobe used for variable data printing. In accordance with the presentinvention, graphics states describing variable data areas are generatedby a page interpreter program and reserved in an internal database. Thegraphics states are later accessed from the database and used forprinting variable data pages. The method of the present invention can beemployed with a conventional page description language, such asPostScript, to enable variable data pages to be printed with a minimumamount of processing.

[0023] As shown in FIG. 1, an image containing text and/or graphics datais created at a workstation 10, using a graphics application programsuch as Adobe Illustrator®. As the image is created, the applicationprogram displays the image on the workstation screen. When the image iscomplete and ready to be printed as a page, the application programgenerates a specification of the image in PostScript in a conventionalmanner.

[0024] After the PostScript file 11 is generated, it is transferred fromthe workstation 10 to a printer generally designated as 12. In theprinter 12, a PostScript interpreter 14 is executed to generate apagemap of the image. In the method of the present invention, a controltask operates in the printer 12 to initiate the PostScript interpreterprogram 14 and a merge task 16. The control task is initiated uponpower-on of the printer 12, and controls and coordinates the variabledata printing.

[0025] As the PostScript interpreter 14 executes, it defines thePostScript graphics state attributes for the page. These attributes caninclude the size, font, position, orientation, and location in which thegraphic or text data is to appear on the page. The specifics of theattributes which are available in PostScript to define how data is toappear on a page would be well-known to one skilled in the art.Therefore, further description of these PostScript attributes is notprovided.

[0026] However, one of the PostScript attributes, namely the region, hasbeen expanded in the present invention to allow for variable dataprinting. In the method of the present invention, the region attributeis used to define the boundaries or extent to which a variable datagraphics state will be allowed to effect a page. The graphics stateextent is an invisible boundary which acts as a clippath for the page,to prevent variable data for a particular graphics state from extendingoutside the intended boundaries of the graphics state. The region of thegraphics state extent is defined without altering PostScript, by usingan ordinary shape, which is created as part of the image, to define theregion. In the present invention, the artist creates a shaperepresenting the extent as part of the page image, and specifies aparticular trigger color or gray scale for the shape. Thus, the artistcould include a medium gray scale rectangle in the upper left-handcorner of the page, with the boundaries of the rectangle representingthe extent which the artist has defined for the graphics statepositioned at that corner of the page. The medium gray scale will thenrepresent the trigger color, and will be specified as the trigger forthe region attribute in a job file 18 in the printer 12.

[0027] In addition, a second parameter in the job file 18 can be used tospecify whether the rectangle should appear on the page, or whether itis being used only to define a graphics state extent. Thus, if theartist also wants the medium gray scale rectangle to appear on theprinted page, this parameter enables the color to act as a trigger, yetnot inhibit the artist's design. When the rectangle is interpretedduring the method of this invention, the control task will detect thetrigger color and will save an “invisible” boundary represented by therectangular as part of the graphics state.

[0028] As the PostScript attributes are defined, they are placed in astack. When a new attribute is defined, it is added to the top of thestack. When an attribute is deleted, it is removed from the stack. Thecombination of all of the attributes located in the stack at any pointduring the execution of the PostScript interpreter 14 constitutes the“current” graphics state for the page.

[0029] When the interpreter reaches a print command, such as “SHOW” inPostScript, the command triggers the control task to interrupt theinterpreter program. During this interruption, the control taskinterprets data in the PostScript file 11 and reserves a graphics stateif the data is variable. Normally in a PostScript file, data which is toappear on the printed document is enclosed within parentheses. Thus, thecontrol task identifies data in the file 11 by locating parentheses inthe code.

[0030] After the control task identifies the data, it interprets thedata to determine whether it is static data, which is to be part of thepage template, or variable data. To interpret the data, the control taskfirst reads the data located in the parentheses and compares the datawith a list of literal data strings stored in the job file 18. The jobfile 18 contains a list of data strings which are each associated withthe name of a graphics state and its corresponding data field in a mergefile 20. In the preferred embodiment, the graphics state name is thesame as the field name in the merge file 20. The merge file 20 containsvariable data arranged in records, with each record corresponding to adifferent page. Each record contains one or more data fields, which eachcorrespond to separate variable data areas on the page. The list of datastrings and associated graphics state names is entered in the job file18 by the print operator prior to initiating the print job. If the datafrom the PostScript file 11 matches a data string in the job file 18,the control task replaces the data from the file 11 with the graphicsstate name associated with the matching data string. In this manner, thecontrol task transforms static data in the PostScript file into avariable data field, by substituting a graphics state field name for thestatic data in the file.

[0031] In a second embodiment, the graphics state name corresponding tothe data area is defined directly within the PostScript file 11, bymaking the name part of the image that is created in the applicationprogram. In this embodiment, the name is enclosed within brackets in thefile, such as “<<>>”, to enable the control task to identify the data asdefining a graphics state rather than being an ordinary data string.Thus, to define the graphics state “ADDRESS” within the PostScript file11, the following would appear before a show command in the code:“(<<ADDRESS>>)”. This second embodiment is advantageous in that it doesnot require the control task to compare the file data with a data listin the job file 18; however, it does require coordinating the graphicsstate and field names between the merge file 20 and the applicationprogram.

[0032] If the control task determines that the data corresponds to avariable area, it reads the current contents of the graphics state stackto determine the attributes to be used for printing data in that area.In addition to the PostScript attributes specified in the stack, thegraphics state can also include attributes which are specificallytailored to variable data printing. These additional attributes caneither appear after the graphics state name inside a “show” command, ifthe graphics state is defined directly in the PostScript file, or can bespecified in the job file 18 prior to execution of the print job. Theseadditional attributes specify how the variable data is to be positionedwithin the graphics state. The following is a list of the variable dataattributes which can be specified for a print job: Name: A label used toidentify the data to which the graphics state applies. A single datummay be inserted into more than one graphics state so this attribute isnot unique to a single state. Glyphs: A list of character glyphs, bothattributes and images, which are available for use in the graphicsstate. (e.g. an alphabet of 72 point Times-Roman bold italiccharacters). Static Data: Data to be used in the event that variabledata is not available. Identification: A number used to uniquelyidentify a graphics state. Justification: How to handle the text left toright—left border, right border, centered or justified. Alignment: Howto place the text vertically in the graphics state. This could be top,bottom or centered. Word Wrapping: Selects a word wrapping algorithm.Dynamic Registration: Information on how to determine the registrationfrom one page to the next. Logic Mode: The manner in which the bitmapmerge takes place. This is one of seven binary combination techniques.DP Procedure: A procedure (or program) used to manipulate the variabledata just before the graphics state is applied. Data Selection: Whichportions of the variable data to use. Underline: Selects underlinedtext.

[0033] When the control task is triggered to reserve a graphics state,the above listed attributes, if specified, are combined with thePostScript attributes from the stack, and reserved as a single graphicsstate under the name obtained from the PostScript file 11 or the jobfile 18 such as shown at 22.

[0034] After the control task has compiled the attributes for thecurrent graphics state, it may instruct PostScript to generate a fontcache 26 for the graphics state. The font cache 26 consists of acharacter bit map for each of the alphanumeric characters A-Z and 0-9generated in the font specified in the graphics state. After PostScripthas generated all of the character bit maps, and placed the bit maps inthe font cache 26, the font cache is linked to the graphics state 22,and reserved in the database. After the control task has reserved thecurrent graphics state 22 and the font cache 26 in the database, itresumes execution of the PostScript interpreter 14 at the first line ofcode after the print or “SHOW” command, so that the print command is notexecuted.

[0035] After the interpreter is resumed, it continues defining graphicsstate attributes for the page, until the control task detects anotherprint or “SHOW” command. Upon detecting another print command, thecontrol task again interrupts execution of the interpreter, anddetermines whether the data in the PostScript file 11 corresponds to avariable data area. If the data corresponds to a variable data area, thecontrol task again substitutes a graphics state name from the job file18 for the data in the PostScript file 11, and reads the graphics stateattributes from the stack and job file. The control task also instructsPostScript to generate another font cache, if the attributes of thecurrent graphics state differ from the attributes of previously reservedgraphics states. The current graphics state and font cache are thenlinked, and reserved in the database under the second graphics statename from the job file 18, such as shown at 24. If the data does notcorrespond to a variable data area, the control task resumes executionof the interpreter at the print command, so that a bit map for the datacan be generated and added to the template.

[0036] At the final line of code, the template is complete, andincorporates all of the static text and graphic data that is to appearon the printed document. At this point, the control task terminates theinterpreter, and saves the template to the database such as shown at 28.In PostScript, the control task is triggered to save the template by the“SHOWPAGE” command.

[0037] Since the control task of the invention operates externally ofthe PostScript interpreter, the method of the present invention enablesbit maps and graphics states to be generated by the interpreter in aconventional manner. However, rather than printing a completed page mapat the end of the interpreter program, the method of this inventionreserves the page maps, character bit maps and graphics states generatedby the interpreter, in order that they may be subsequently accessed andused to print multiple pages of variable data.

[0038] After the interpreter has been terminated, the control taskinitiates the merge task 16. The merge task 16 interfaces between themerge file 20, which has been pre-programmed with items of variabledata, and the database in which the templates, font caches and graphicsstates defined by the interpreter have been saved, in order to combinethe variable data with a template on a single page map. The merge task16 begins by accessing the merge file 20 to retrieve the name of thetemplate for the page, and then retrieving the specified template fromthe database. In addition, the merge task 16 retrieves the names of thedata fields and reserved graphics states which are associated with theselected template from the merge file 20.

[0039] Using the name corresponding to the first graphics state on thepage, the merge task 16 accesses the merge file 20 and retrieves thedata stored under that field name in the first data record. In therepresentative merge file 20 shown in FIG. 1, the field names are NAMEand NUMBER.

[0040] After the merge task 16 has read the data corresponding to thedesignated field name, it retrieves the graphics state which wasreserved under the same name, as well as the character bit maps whichare linked to that graphics state. The merge task 16 then generates abit map of the data in accordance with the graphics state attributes.After the bit map is generated, it is merged into the template at theregion corresponding to the graphics state, by writing the data bit mapover the existing template bit map.

[0041] It will be apparent to those of ordinary skill in the art that itis within the scope of the invention to write the data bit map over aclean page as opposed to the template bitmap. For example, if thetemplate contains no static bitmap data, then it would not be necessaryto save an empty bitmap of the template in the database as describedabove. Thus, it is within the scope of the invention that the PostScriptfile 11 defines only variable data areas and does not define any staticdata areas. Such a PostScript file is illustrated in FIG. 1.

[0042] After the data from the first field has been merged into thetemplate, the merge task 16 reads the name corresponding to a secondvariable data area from the merge file 20, if a second variable areaexists on the page. The merge task 16 then retrieves the graphics stateand linked font cache having the same name as the second variable area.Next, using this name, the merge task 16 again accesses the merge file20, and reads the data from the field of the same name. The merge task16 then generates a bit map for the data in accordance with the graphicsstate and font cache, and again merges the data bit map into thetemplate 28.

[0043] The merge task 16 continues the steps of identifying variabledata areas for the template, retrieving graphics states and characterbit maps corresponding to the variable areas, accessing variable datafrom the merge file 20, and generating bit maps for the variable data,until bit maps have been generated and merged for all of the variabledata to be included on the page. When a bit map has been generated foreach variable data area, and merged with the template 28, the pagemap isoutput for printing as shown at 29.

[0044] The merge task 16 then proceeds with printing a second page usingthe same template and graphics states, but a different variable datarecord in the merge file 20. To print the second page, the merge task 16retrieves a “clean” template from the database. Next, the merge task 16again identifies the name of the first variable data area for thattemplate and retrieves the graphics state of the same name. Then, themerge task 16 reads the data for that field from the second record ofthe merge file 20, and generates a bit map of the data using theretrieved graphics state attributes and character bit maps. Once the bitmap is generated, the merge task 16 merges the bit map into the templateby writing the bit map over the template at the location defined by thegraphics state.

[0045] The merge task 16 then continues processing in this manner untilbit maps have been generated and merged into the template for all of thegraphics states reserved for the page. After all of the bit maps for thesecond page have been merged into the template, the page is printed. Themerge task 16 continues, repeating these steps for each record of datain the merge file 20, until all of the variable data records have beenprinted on a page.

[0046]FIG. 2 shows a variable data page printed in accordance with themethod of this invention. On this page, the data fields 30 and 32 arestatic fields which are part of the page template. The data field 34containing the name “William” is a variable data field. Different namessuch as Mark or Sam, from the merge file 20, are printed in this fieldon subsequent pages. The font, angle and color contrast in which“William” is displayed are all aspects of the graphics state which weredefined and stored during the steps of the present invention. Data field36 which contains the number “00467727” is a second variable data areaon the page. Again, the data displayed in this area varies on each page,depending upon the contents of the merge file 20.

[0047] While the method described constitutes a preferred embodiment ofthe invention, it is to be understood that the present invention is notlimited to this precise form, and that variations may be made withoutdeparting from the scope of the invention.

What is claimed is:
 1. A computer implemented method for generating aplurality of bitmaps suitable for printing comprising the steps of: (a)interpreting a page description code specification, the page descriptioncode specification defining at least one template bitmap and includingat least one data area into which at least one of a plurality of avariable bitmaps is to be merged, the interpreting step including a stepof identifying the data area; (b) producing a first template bitmap; (c)merging at least a first one of the plurality of variable bitmaps intothe one data area of the first template bitmap to create a first mergedbitmap; (d) printing the first merged bitmap; (e) producing a nexttemplate bitmap; (f) merging at least a next one of the plurality ofvariable bitmaps into the one data area of the next template bitmap; (g)printing the next merged bitmap; and (h) repeating steps (e) through (g)for the plurality of variable bitmaps.
 2. The computer implementedmethod of claim 1, wherein the plurality of variable bitmaps are aplurality of character bitmaps.
 3. The computer implemented method ofclaim 2, wherein the interpreting step includes the step of creating theplurality of character bitmaps.
 4. The computer implemented method ofclaim 3, wherein the step of creating the plurality of character bitmapsincludes the step of applying an attribute in the page description codespecification associated with the data area to a plurality ofcharacters.
 5. The computer implemented method of claim 4, wherein theattribute defines an aspect of how data is to appear in the data area.6. The computer implemented method of claim 5, wherein the attribute isa graphics state defined for the data area.
 7. The computer implementedmethod of claim 5, wherein the attribute defines a position of thevariable data bitmap with respect to the template bitmap.
 8. Thecomputer implemented method of claim 5, wherein the attribute defines anorientation of the variable data bitmap with respect to the templatebitmap.
 9. The computer implemented method of claim 1, wherein theinterpreting step includes the step of creating the plurality ofvariable bitmaps.
 10. The computer implemented method of claim 9,wherein the step of creating the plurality of variable bitmaps includesthe step of applying an attribute in the page description codespecification associated with the data area to a plurality of variabledata items.
 11. The computer implemented method of claim 10, wherein theattribute defines an aspect of how bitmap data is to appear in the dataarea.
 12. The computer implemented method of claim 11, wherein theattribute is a graphics state defined for the data area.
 13. Thecomputer implemented method of claim 11, wherein the attribute defines aposition of the variable data bitmap with respect to the templatebitmap.
 14. The computer implemented method of claim 11, wherein theattribute defines an orientation of the variable data bitmap withrespect to the template bitmap.
 15. The computer implemented method ofclaim 10, wherein the step of creating the plurality of variable databitmaps further includes the step of applying an attribute defined in anexternal file to the plurality of data items.
 16. The computerimplemented method of claim 15, wherein the step of creating theplurality of variable data bitmaps further includes the step ofassociating the attribute defined in the external file with the dataarea.
 17. The computer implemented method of claim 1, wherein the stepof producing the first template bitmap includes the step of processing aportion of the page description code specification defining the at leastone template bitmap to generate the first template bitmap.
 18. Thecomputer implemented method of claim 17, wherein the step of producingthe first template bitmap further includes the step of storing the firsttemplate bitmap in memory.
 19. The computer implemented method of claim18, wherein the step of producing the next template bitmap includes thestep of accessing a copy of the first template bitmap stored in memory.20. The computer implemented method of claim 17, wherein the step ofprocessing the a portion of the page description code specificationdefining at least one template bitmap to generate the first templatebitmap further includes the step of not processing a portion of the pagedescription code specification defining the at least one data area intowhich at least one of a plurality of a variable bitmaps is to be merged.21. A computer implemented method for generating a plurality of bitmapssuitable for printing comprising the steps of: providing a pagedescription code specification defining at least one template bitmap andincluding at least one data area into which at least one of a pluralityof bitmaps is to be merged; providing a file external to the pagedescription code specification including at least one attribute itemdefining an aspect of how bitmap data is to appear on a printed page;processing the page description code specification to generate atemplate bitmap, and during the processing step, identifying the dataarea; upon identifying the data area, applying the attribute defined bythe attribute item in the external file to a first one of the pluralityof bitmaps; and merging the first one of the plurality of bitmaps withthe template bitmap.
 22. The computer implemented method of claim 21,further comprising the step of, prior to applying the attribute definedby the attribute item in the external file, associating the data areawith the attribute item in the external file.
 23. The computerimplemented method of claim 21, wherein the attribute defined by theattribute item in the external file is horizontal justificationattribute.
 24. The computer implemented method of claim 21, wherein theattribute defined by the attribute item in the external file is avertical alignment attribute.
 25. The computer implemented method ofclaim 21, wherein the attribute defined by the attribute item in theexternal file is a word wrapping algorithm.
 26. The computer implementedmethod of claim 21, wherein the attribute defined by the attribute itemin the external file is a binary logic designation defining how thefirst one of the plurality of bitmaps is to be merged with the templatebitmap.
 27. The computer implemented method of claim 21, wherein theattribute defined by the attribute item in the external file is anunderlined text attribute.
 28. A computer implemented method forgenerating a plurality of bitmaps suitable for printing comprising thesteps of: providing a page description code specification defining atleast one template bitmap and including at least one data area intowhich at least one of a plurality of variable data bitmaps is to bemerged; providing a job file external to the page description codespecification including at least one attribute item defining an aspectof how bitmap data is to appear on a printed page; providing a mergefile external to the page description code specification include aplurality of variable data items; processing the page description codespecification to generate a template bitmap, and during the processingstep, identifying the data area; upon identifying the data area,applying the attribute defined by the attribute item in the job file toa first one of the variable data items in the merge file in thegeneration of a variable data bitmap; and merging the variable databitmap with the template bitmap.
 29. The computer implemented method ofclaim 28, wherein the attribute defined by the attribute item in the jobfile is horizontal justification attribute.
 30. The computer implementedmethod of claim 28, wherein the attribute defined by the attribute itemin the job file is a vertical alignment attribute.
 31. The computerimplemented method of claim 28, wherein the attribute defined by theattribute item in the job file is a word wrapping algorithm.
 32. Thecomputer implemented method of claim 28, wherein the attribute definedby the attribute item in the job file is a binary logic designationdefining how the variable data bitmap is to be merged with the templatebitmap.
 33. The computer implemented method of claim 28, wherein theattribute defined by the attribute item in the job file is an underlinedtext attribute.
 34. The computer implemented method of claim 28, whereinthe attribute item in the job file defines a procedure to manipulate thevariable data item.
 35. The computer implemented method of claim 28,wherein the attribute item in the job file defines a static data item tobe used in the generation of the variable data bitmap if the variabledata item is not available.
 36. A computer implemented method forgenerating bit maps suitable for printing comprising the steps of: (a)providing a page description code specification, the page descriptioncode specification defining at least one data area; (b) identifying thedata area defined by the page description code specification; (c) uponidentification of the data area in step (b), associating with the dataarea an attribute defining an aspect of the appearance of data in thedata area, and applying the attribute to a set of characters so as togenerate a plurality of character bitmaps; (d) associating a firstvariable data item from a set of variable data items with the characterbitmaps; and (e) generating a first variable data bitmap for the firstvariable data item using the character bitmaps.
 37. The computerimplemented method of claim 36, further comprising the steps of: (f)associating a next variable item from the set of variable data itemswith the character bitmaps; (g) generating a next variable data bitmapfor the next variable data item using the character bitmaps; and (h)repeating steps (f) and (g) for a plurality of the variable data itemsin the set of variable data items.
 38. The computer implemented methodof claim 37, wherein the page description code specification representsa template and includes a static data area, and the computer implementedmethod further comprises the steps of: executing portions of the pagedescription code specification corresponding to the static data area togenerate a template bitmap; merging the first variable data bitmap intothe template bitmap or a copy of the template bitmap to generate a firstmerged bitmap; and merging the next variable data bitmaps into thetemplate bitmap or a copy of the template bitmap to generate a pluralityof next merged bitmaps.
 39. The computer implemented method of claim 36,wherein the page description code specification represents a templateand includes a static data area, and the computer implemented methodfurther comprises the steps of: executing portions of the pagedescription code specification corresponding to the static data area togenerate a template bitmap; and merging the first variable data bitmapinto the template bitmap or a copy of the template bitmap to generate afirst merged bitmap.
 40. The computer implemented method of claim 36,wherein the attribute defining an aspect of the appearance of data inthe data area is provided in the page description code specification.41. The computer implemented method of claim 40, wherein the attributedefining an aspect of the appearance of data in the data area is anattribute associated with the data area.
 42. The computer implementedmethod of claim 36, wherein the attribute defining an aspect of theappearance of data in the data area is provided in a file external tothe page description code specification.